// 版权所有2009 Go作者。保留所有权利。
// 此源代码的使用受BSD样式
// 许可证的约束，该许可证可以在许可证文件中找到。

// Package scanner为Go源文本实现了一个扫描仪。
// 它以[]字节作为源，然后可以通过重复调用Scan方法将其标记为
// 。
// 
package scanner

import (
	"bytes"
	"fmt"
	"go/token"
	"path/filepath"
	"strconv"
	"unicode"
	"unicode/utf8"
)

// 可能会向扫描仪提供错误处理程序。初始化。如果遇到语法错误
// 并且安装了处理程序，则会使用
// 位置和错误消息调用该处理程序。该位置指向
// 冒犯标记的开头。
// 
type ErrorHandler func(pos token.Position, msg string)

// 扫描器在处理给定文本时保存扫描器的内部状态。它可以作为另一个数据
// 结构的一部分进行分配，但在使用之前必须通过Init进行初始化。
// 
type Scanner struct {
	// 不可变状态
	file *token.File  // 源文件句柄
	dir  string       // 文件的目录部分。Name（）
	src  []byte       // 源
	err  ErrorHandler // 错误报告；或nil 
	mode Mode         // 扫描模式

	// 扫描状态
	ch         rune // 当前字符
	offset     int  // 字符偏移量
	rdOffset   int  // 读取偏移量（当前字符后的位置）
	lineOffset int  // 当前行偏移量
	insertSemi bool // 在下一行

	// 公共状态-确定修改
	ErrorCount int // /遇到的错误数
}

const (
	bom = 0xFEFF // 字节顺序标记，仅允许作为第一个字符
	eof = -1     // 文件结束
)

// 将下一个Unicode字符读入s.ch。
// s.ch<0表示文件结束。
// 
// 为了优化，该方法与
// s.scanIdentifier之间存在一些重叠。
func (s *Scanner) next() {
	if s.rdOffset < len(s.src) {
		s.offset = s.rdOffset
		if s.ch == '\n' {
			s.lineOffset = s.offset
			s.file.AddLine(s.offset)
		}
		r, w := rune(s.src[s.rdOffset]), 1
		switch {
		case r == 0:
			s.error(s.offset, "illegal character NUL")
		case r >= utf8.RuneSelf:
			// 非ASCII 
			r, w = utf8.DecodeRune(s.src[s.rdOffset:])
			if r == utf8.RuneError && w == 1 {
				s.error(s.offset, "illegal UTF-8 encoding")
			} else if r == bom && s.offset > 0 {
				s.error(s.offset, "illegal byte order mark")
			}
		}
		s.rdOffset += w
		s.ch = r
	} else {
		s.offset = len(s.src)
		if s.ch == '\n' {
			s.lineOffset = s.offset
			s.file.AddLine(s.offset)
		}
		s.ch = eof
	}
}

// peek返回不带
// 的最近读取字符后的字节。如果扫描仪处于EOF，peek返回0。
func (s *Scanner) peek() byte {
	if s.rdOffset < len(s.src) {
		return s.src[s.rdOffset]
	}
	return 0
}

// 模式值是一组标志（或0）。
// 它们控制扫描仪的行为。
// 
type Mode uint

const (
	ScanComments    Mode = 1 << iota // 将注释作为注释标记返回
	dontInsertSemis                  // 不要自动插入分号-仅用于测试
)

// Init通过在src开头设置
// 扫描器，准备扫描器s标记文本src。扫描仪使用文件集
// 作为位置信息，并为每一行添加行信息。
// 当重新扫描与
// 相同的文件时，可以重新使用相同的文件。已存在的行信息将被忽略。如果文件大小与src大小不匹配，Init会导致
// 死机。
// 
// 如果遇到
// 语法错误且err不为零，则对Scan的调用将调用错误处理程序err。此外，对于遇到的每个错误，
// 扫描仪字段错误计数将增加1。模式参数
// 决定如何处理注释。
// 
// 请注意，如果文件的第一个字符
// 中存在错误，Init可能会调用err。
// 
func (s *Scanner) Init(file *token.File, src []byte, err ErrorHandler, mode Mode) {
	// 显式初始化所有字段，因为扫描仪可以重复使用。
	if file.Size() != len(src) {
		panic(fmt.Sprintf("file size (%d) does not match src len (%d)", file.Size(), len(src)))
	}
	s.file = file
	s.dir, _ = filepath.Split(file.Name())
	s.src = src
	s.err = err
	s.mode = mode

	s.ch = ' '
	s.offset = 0
	s.rdOffset = 0
	s.lineOffset = 0
	s.insertSemi = false
	s.ErrorCount = 0

	s.next()
	if s.ch == bom {
		s.next() // 忽略文件开头的BOM 
	}
}

func (s *Scanner) error(offs int, msg string) {
	if s.err != nil {
		s.err(s.file.Position(s.file.Pos(offs)), msg)
	}
	s.ErrorCount++
}

func (s *Scanner) errorf(offs int, format string, args ...any) {
	s.error(offs, fmt.Sprintf(format, args...))
}

func (s *Scanner) scanComment() string {
	// 初始'/'已使用；s、 ch='/'| s.ch='*'
	offs := s.offset - 1 // 注释后面紧跟的“/”
	next := -1           // 位置的初始位置；<0表示无效注释
	numCR := 0

	if s.ch == '/' {
		// -风格注释
		// （最后的“\n”不被视为注释的一部分）
		s.next()
		for s.ch != '\n' && s.ch >= 0 {
			if s.ch == '\r' {
				numCR++
			}
			s.next()
		}
		// 如果我们在“\n”，注释后面的位置是Windows上的
		next = s.offset
		if s.ch == '\n' {
			next++
		}
		goto exit
	}

	/*-style comment */
	s.next()
	for s.ch >= 0 {
		ch := s.ch
		if ch == '\r' {
			numCR++
		}
		s.next()
		if ch == '*' && s.ch == '/' {
			s.next()
			next = s.offset
			goto exit
		}
	}

	s.error(offs, "comment not terminated")

exit:
	lit := s.src[offs:s.offset]

	// 之后，a（
	// 在分析
	// 行指令（与编译器匹配）的文本之前，删除最后的'\r'。删除任何
	// other'\r'（与之前存在的be-
	// havior扫描仪匹配）。
	if numCR > 0 && len(lit) >= 2 && lit[1] == '/' && lit[len(lit)-1] == '\r' {
		lit = lit[:len(lit)-1]
		numCR--
	}

	// 解释行指令
	// （
	if next >= 0 /* implies valid comment */ && (lit[1] == '*' || offs == s.lineOffset) && bytes.HasPrefix(lit[2:], prefix) {
		s.updateLineInfo(next, offs, lit)
	}

	if numCR > 0 {
		lit = stripCR(lit, lit[1] == '*')
	}

	return string(lit)
}

var prefix = []byte("line ")

// UPDATELINEFO将偏移量处的传入注释文本
// 解析为行指令。如果成功，它将根据行指令更新下一个位置的行信息表
// 提取注释文本
func (s *Scanner) updateLineInfo(next, offs int, text []byte) {
	if text[1] == '*' {
		text = text[:len(text)-2] // 删除尾随“*”
	}
	text = text[7:] // lop off leading“
	offs += 7

	i, n, ok := trailingDigits(text)
	if i == 0 {
		return // ignore（非行指令）
	}
	// i>0 

	if !ok {
		// text有后缀：xxx但xxx不是数字
		s.error(offs+i, "invalid line number: "+string(text[i:]))
		return
	}

	var line, col int
	i2, n2, ok2 := trailingDigits(text[:i-1])
	if ok2 {
		// line文件名：line:col 
		i, i2 = i2, i
		line, col = n2, n
		if col == 0 {
			s.error(offs+i2, "invalid column number: "+string(text[i2:]))
			return
		}
		text = text[:i2-1] // lop off:col 
	} else {
		// 行文件名：行
		line = n
	}

	if line == 0 {
		s.error(offs+i, "invalid line number: "+string(text[i:]))
		return
	}

	// 如果我们有一列（
	// 空文件名意味着使用以前的文件名。
	filename := string(text[:i-1]) // 删除：行”，并修剪空白
	if filename == "" && ok2 {
		filename = s.file.Position(s.file.Pos(offs)).Filename
	} else if filename != "" {
		// 在当前目录中放置一个相对文件名。
		// 这是为了与早期版本兼容。
		// 见第26671期。
		filename = filepath.Clean(filename)
		if !filepath.IsAbs(filename) {
			filename = filepath.Join(s.dir, filename)
		}
	}

	s.file.AddLineColumnInfo(next, filename, line, col)
}

func trailingDigits(text []byte) (int, int, bool) {
	i := bytes.LastIndexByte(text, ':') // 从右边看（Windows文件名可能包含“：”）
	if i < 0 {
		return 0, 0, false // 否：“
	}
	// i>=0 
	n, err := strconv.ParseUint(string(text[i+1:]), 10, 0)
	return i + 1, int(n), err == nil
}

func (s *Scanner) findLineEnd() bool {
	// 初始'/'已使用

	defer func(offs int) {
		// 将扫描程序状态重置为调用findLineEnd 
		s.ch = '/'
		s.offset = offs
		s.rdOffset = offs + 1
		s.next() // 再次使用初始'/'
	}(s.offset - 1)

	// 继续阅读，直到换行，EOF，或者找到非注释标记
	for s.ch == '/' || s.ch == '*' {
		if s.ch == '/' {
			// -样式注释始终包含换行符
			return true
		}
		/*-style comment: look for newline */
		s.next()
		for s.ch >= 0 {
			ch := s.ch
			if ch == '\n' {
				return true
			}
			s.next()
			if ch == '*' && s.ch == '/' {
				s.next()
				break
			}
		}
		s.skipWhitespace() // s.insertSemi设置为
		if s.ch < 0 || s.ch == '\n' {
			return true
		}
		if s.ch != '/' {
			// /非注释标记
			return false
		}
		s.next() // consume'/'
	}

	return false
}

func isLetter(ch rune) bool {
	return 'a' <= lower(ch) && lower(ch) <= 'z' || ch == '_' || ch >= utf8.RuneSelf && unicode.IsLetter(ch)
}

func isDigit(ch rune) bool {
	return isDecimal(ch) || ch >= utf8.RuneSelf && unicode.IsDigit(ch)
}

// scanIdentifier读取s.offset处的有效标识符字符字符串。
// 只有在已知s.ch是有效字母时才能调用它。
// 
// 更改此函数时要小心：它经过优化，对
// 扫描性能有显著影响。
func (s *Scanner) scanIdentifier() string {
	offs := s.offset

	// 针对ASCII标识符的常见情况进行优化。
	// 
	// 在s.src[s.rdOffset:]上进行测距可以避免一些边界检查，而
	// 可以避免转换为符文。
	// 
	// 如果遇到非ASCII字符，请返回调用s.next（）的较慢路径。
	for rdOffset, b := range s.src[s.rdOffset:] {
		if 'a' <= b && b <= 'z' || 'A' <= b && b <= 'Z' || b == '_' || '0' <= b && b <= '9' {
			// 避免为ascii字符的常见大小写指定符文。
			continue
		}
		s.rdOffset += rdOffset
		if 0 < b && b < utf8.RuneSelf {
			// 优化：我们遇到了一个ASCII字符，它不是字母
			// 或数字。避免调用s.next（）和相应的设置。
			// 
			// 注意，如果s.ch是'\n'，s.next（）会进行一些行计算，所以这个
			// 快捷方式是可能的，因为我们知道前面的字符
			// 不是'\n'。
			s.ch = rune(b)
			s.offset = s.rdOffset
			s.rdOffset++
			goto exit
		}
		// 我们知道前面的字符对于标识符是有效的，因为
		// scanIdentifier只在s.ch是字母时被调用，所以在s.rdOffset调用s.next（）
		// 会重置扫描程序状态。
		s.next()
		for isLetter(s.ch) || isDigit(s.ch) {
			s.next()
		}
		goto exit
	}
	s.offset = len(s.src)
	s.rdOffset = len(s.src)
	s.ch = eof

exit:
	return string(s.src[offs:s.offset])
}

func digitVal(ch rune) int {
	switch {
	case '0' <= ch && ch <= '9':
		return int(ch - '0')
	case 'a' <= lower(ch) && lower(ch) <= 'f':
		return int(lower(ch) - 'a' + 10)
	}
	return 16 // 大于任何合法数字val 
}

func lower(ch rune) rune     { return ('a' - 'A') | ch } // 返回小写字母ch，如果ch是ASCII字母
func isDecimal(ch rune) bool { return '0' <= ch && ch <= '9' }
func isHex(ch rune) bool     { return '0' <= ch && ch <= '9' || 'a' <= lower(ch) && lower(ch) <= 'f' }

// 数字接受序列{digit |''}。
// 如果基数<=10，则数字接受任何十进制数字，但记录
// 一个数字的偏移量>=base 
// 在*无效，如果*无效<0。
// digits返回一个位集，该位集描述序列中包含的是
// 位（设置了位0）还是分隔符“u”（设置了位1）。
func (s *Scanner) digits(base int, invalid *int) (digsep int) {
	if base <= 10 {
		max := rune('0' + base)
		for isDecimal(s.ch) || s.ch == '_' {
			ds := 1
			if s.ch == '_' {
				ds = 2
			} else if s.ch >= max && *invalid < 0 {
				*invalid = s.offset // 记录无效符文偏移量
			}
			digsep |= ds
			s.next()
		}
	} else {
		for isHex(s.ch) || s.ch == '_' {
			ds := 1
			if s.ch == '_' {
				ds = 2
			}
			digsep |= ds
			s.next()
		}
	}
	return
}

func (s *Scanner) scanNumber() (token.Token, string) {
	offs := s.offset
	tok := token.ILLEGAL

	base := 10        // 数字基
	prefix := rune(0) // 0（十进制）、'0'（0-八进制）、'x'、'o'或'b'中的一个
	digsep := 0       // 位0：存在数字，位1:'存在
	invalid := -1     // 文本中无效数字的索引，或<0 

	// 整数部分
	if s.ch != '.' {
		tok = token.INT
		if s.ch == '0' {
			s.next()
			switch lower(s.ch) {
			case 'x':
				s.next()
				base, prefix = 16, 'x'
			case 'o':
				s.next()
				base, prefix = 8, 'o'
			case 'b':
				s.next()
				base, prefix = 2, 'b'
			default:
				base, prefix = 8, '0'
				digsep = 1 // 前导0 
			}
		}
		digsep |= s.digits(base, &invalid)
	}

	// 小数部分
	if s.ch == '.' {
		tok = token.FLOAT
		if prefix == 'o' || prefix == 'b' {
			s.error(s.offset, "invalid radix point in "+litname(prefix))
		}
		s.next()
		digsep |= s.digits(base, &invalid)
	}

	if digsep&1 == 0 {
		s.error(s.offset, litname(prefix)+" has no digits")
	}

	// 指数
	if e := lower(s.ch); e == 'e' || e == 'p' {
		switch {
		case e == 'e' && prefix != 0 && prefix != '0':
			s.errorf(s.offset, "%q exponent requires decimal mantissa", s.ch)
		case e == 'p' && prefix != 'x':
			s.errorf(s.offset, "%q exponent requires hexadecimal mantissa", s.ch)
		}
		s.next()
		tok = token.FLOAT
		if s.ch == '+' || s.ch == '-' {
			s.next()
		}
		ds := s.digits(10, nil)
		digsep |= ds
		if ds&1 == 0 {
			s.error(s.offset, "exponent has no digits")
		}
	} else if prefix == 'x' && tok == token.FLOAT {
		s.error(s.offset, "hexadecimal mantissa requires a 'p' exponent")
	}

	// 后缀'i'
	if s.ch == 'i' {
		tok = token.IMAG
		s.next()
	}

	lit := string(s.src[offs:s.offset])
	if tok == token.INT && invalid >= 0 {
		s.errorf(invalid, "invalid digit %q in %s", lit[invalid-offs], litname(prefix))
	}
	if digsep&2 != 0 {
		if i := invalidSep(lit); i >= 0 {
			s.error(offs+i, "'_' must separate successive digits")
		}
	}

	return tok, lit
}

func litname(prefix rune) string {
	switch prefix {
	case 'x':
		return "hexadecimal literal"
	case 'o', '0':
		return "octal literal"
	case 'b':
		return "binary literal"
	}
	return "decimal literal"
}

// invalidSep返回x中第一个无效分隔符的索引，或-1。
func invalidSep(x string) int {
	x1 := ' ' // 前缀char，我们只关心它是否是'x'
	d := '.'  // 数字，是'u'、'0'（一个数字）或'.'中的一个（其他任何内容）
	i := 0

	// 前缀算作数字
	if len(x) >= 2 && x[0] == '0' {
		x1 = lower(rune(x[1]))
		if x1 == 'x' || x1 == 'o' || x1 == 'b' {
			d = '0'
			i = 2
		}
	}

	// 尾数和指数
	for ; i < len(x); i++ {
		p := d // 前一个数字
		d = rune(x[i])
		switch {
		case d == '_':
			if p != '0' {
				return i
			}
		case isDecimal(d) || x1 == 'x' && isHex(d):
			d = '0'
		default:
			if p == '_' {
				return i - 1
			}
			d = '.'
		}
	}
	if d == '_' {
		return len(x) - 1
	}

	return -1
}

// scanEscape解析一个转义序列，其中rune是可接受的
// 转义引号。如果出现语法错误，它将停止在有问题的
// 字符处（不使用它），并返回false。否则返回true。
func (s *Scanner) scanEscape(quote rune) bool {
	offs := s.offset

	var n int
	var base, max uint32
	switch s.ch {
	case 'a', 'b', 'f', 'n', 'r', 't', 'v', '\\', quote:
		s.next()
		return true
	case '0', '1', '2', '3', '4', '5', '6', '7':
		n, base, max = 3, 8, 255
	case 'x':
		s.next()
		n, base, max = 2, 16, 255
	case 'u':
		s.next()
		n, base, max = 4, 16, unicode.MaxRune
	case 'U':
		s.next()
		n, base, max = 8, 16, unicode.MaxRune
	default:
		msg := "unknown escape sequence"
		if s.ch < 0 {
			msg = "escape sequence not terminated"
		}
		s.error(offs, msg)
		return false
	}

	var x uint32
	for n > 0 {
		d := uint32(digitVal(s.ch))
		if d >= base {
			msg := fmt.Sprintf("illegal character %#U in escape sequence", s.ch)
			if s.ch < 0 {
				msg = "escape sequence not terminated"
			}
			s.error(s.offset, msg)
			return false
		}
		x = x*base + d
		s.next()
		n--
	}

	if x > max || 0xD800 <= x && x < 0xE000 {
		s.error(offs, "escape sequence is invalid Unicode code point")
		return false
	}

	return true
}

func (s *Scanner) scanRune() string {
	// /'\''开场白已消耗
	offs := s.offset - 1

	valid := true
	n := 0
	for {
		ch := s.ch
		if ch == '\n' || ch < 0 {
			// 只有在我们没有一个已消耗
			if valid {
				s.error(offs, "rune literal not terminated")
				valid = false
			}
			break
		}
		s.next()
		if ch == '\'' {
			break
		}
		n++
		if ch == '\\' {
			if !s.scanEscape('\'') {
				valid = false
			}
			// 继续读到结尾引用
		}
	}

	if valid && n != 1 {
		s.error(offs, "illegal rune literal")
	}

	return string(s.src[offs:s.offset])
}

func (s *Scanner) scanString() string {
	// /'“'开场白已消耗
	offs := s.offset - 1

	for {
		ch := s.ch
		if ch == '\n' || ch < 0 {
			s.error(offs, "string literal not terminated")
			break
		}
		s.next()
		if ch == '"' {
			break
		}
		if ch == '\\' {
			s.scanEscape('"')
		}
	}

	return string(s.src[offs:s.offset])
}

func stripCR(b []byte, comment bool) []byte {
	c := make([]byte, len(b))
	i := 0
	for j, ch := range b {
		// 在一个/*-风格的注释中，不要从*\r/（包括
		// 从*\r\r由于生成的
		// /*/会过早终止评论，除非\r 
		// 紧跟在开头之后
		// 没有问题，因为
		if ch != '\r' || comment && i > len("/*") && c[i-1] == '*' && j+1 < len(b) && b[j+1] == '/' {
			c[i] = ch
			i++
		}
	}
	return c[:i]
}

func (s *Scanner) scanRawString() string {
	// /'``打开已使用
	offs := s.offset - 1

	hasCR := false
	for {
		ch := s.ch
		if ch < 0 {
			s.error(offs, "raw string literal not terminated")
			break
		}
		s.next()
		if ch == '`' {
			break
		}
		if ch == '\r' {
			hasCR = true
		}
	}

	lit := s.src[offs:s.offset]
	if hasCR {
		lit = stripCR(lit, false)
	}

	return string(lit)
}

func (s *Scanner) skipWhitespace() {
	for s.ch == ' ' || s.ch == '\t' || s.ch == '\n' && !s.insertSemi || s.ch == '\r' {
		s.next()
	}
}

// 用于扫描多字节令牌（如>>+=>>=）的辅助函数。
// 不同的例程根据匹配
// 。否则，如果没有其他
// 匹配字符，则结果为tok0，如果匹配字符为ch2，则结果为tok2。

func (s *Scanner) switch2(tok0, tok1 token.Token) token.Token {
	if s.ch == '=' {
		s.next()
		return tok1
	}
	return tok0
}

func (s *Scanner) switch3(tok0, tok1 token.Token, ch2 rune, tok2 token.Token) token.Token {
	if s.ch == '=' {
		s.next()
		return tok1
	}
	if s.ch == ch2 {
		s.next()
		return tok2
	}
	return tok0
}

func (s *Scanner) switch4(tok0, tok1 token.Token, ch2 rune, tok2, tok3 token.Token) token.Token {
	if s.ch == '=' {
		s.next()
		return tok1
	}
	if s.ch == ch2 {
		s.next()
		if s.ch == '=' {
			s.next()
			return tok3
		}
		return tok2
	}
	return tok0
}

// 扫描扫描下一个令牌并返回令牌位置、令牌、
// 及其文字字符串（如果适用）。源端由
// 令牌表示。EOF。
// 
// 如果返回的令牌是文本（token.IDENT、token.INT、token.FLOAT、
// token.IMAG、token.CHAR、token.STRING）或令牌。注释，文本字符串
// 具有相应的值。
// 
// 如果返回的令牌是关键字，则文本字符串是关键字。
// 
// 如果返回的令牌是令牌。分号，对应的
// 文本字符串为“；”如果分号出现在源中，
// 和“\n”如果分号是因为换行符或
// 在EOF插入的。
// 
// 如果返回的令牌是令牌。非法，文本字符串是
// 违规字符。
// 
// 在所有其他情况下，Scan返回一个空的文本字符串。
// 
// 为了更宽容的解析，如果
// 即使遇到语法错误，扫描也将返回有效的令牌。因此，即使是
// 如果生成的令牌序列不包含非法令牌，
// 客户端也可能不会认为没有发生错误。相反，它必须检查扫描器的错误计数或错误处理程序的调用次数（如果已安装）。
// 
// Scan将行信息添加到添加到文件
// 用Init设置的文件中。令牌位置与文件
// 有关，因此与文件集有关。
// 
func (s *Scanner) Scan() (pos token.Pos, tok token.Token, lit string) {
scanAgain:
	s.skipWhitespace()

	// 当前令牌开始
	pos = s.file.Pos(s.offset)

	// 确定令牌值
	insertSemi := false
	switch ch := s.ch; {
	case isLetter(ch):
		lit = s.scanIdentifier()
		if len(lit) > 1 {
			// 关键字超过一个字母-避免查找否则
			tok = token.Lookup(lit)
			switch tok {
			case token.IDENT, token.BREAK, token.CONTINUE, token.FALLTHROUGH, token.RETURN:
				insertSemi = true
			}
		} else {
			insertSemi = true
			tok = token.IDENT
		}
	case isDecimal(ch) || ch == '.' && isDecimal(rune(s.peek())):
		insertSemi = true
		tok, lit = s.scanNumber()
	default:
		s.next() // 始终取得进展
		switch ch {
		case -1:
			if s.insertSemi {
				s.insertSemi = false // 消耗的EOF 
				return pos, token.SEMICOLON, "\n"
			}
			tok = token.EOF
		case '\n':
			// 我们只有在s.insertSemi是
			// 首先设置并提前退出
			// 来自s.skipWhitespace（）
			s.insertSemi = false // 新线消费
			return pos, token.SEMICOLON, "\n"
		case '"':
			insertSemi = true
			tok = token.STRING
			lit = s.scanString()
		case '\'':
			insertSemi = true
			tok = token.CHAR
			lit = s.scanRune()
		case '`':
			insertSemi = true
			tok = token.STRING
			lit = s.scanRawString()
		case ':':
			tok = s.switch2(token.COLON, token.DEFINE)
		case '.':
			// 以“.”开头的分数由外部开关
			tok = token.PERIOD
			if s.ch == '.' && s.peek() == '.' {
				s.next()
				s.next() // 消耗最后一个”处理
				tok = token.ELLIPSIS
			}
		case ',':
			tok = token.COMMA
		case ';':
			tok = token.SEMICOLON
			lit = ";"
		case '(':
			tok = token.LPAREN
		case ')':
			insertSemi = true
			tok = token.RPAREN
		case '[':
			tok = token.LBRACK
		case ']':
			insertSemi = true
			tok = token.RBRACK
		case '{':
			tok = token.LBRACE
		case '}':
			insertSemi = true
			tok = token.RBRACE
		case '+':
			tok = s.switch3(token.ADD, token.ADD_ASSIGN, '+', token.INC)
			if tok == token.INC {
				insertSemi = true
			}
		case '-':
			tok = s.switch3(token.SUB, token.SUB_ASSIGN, '-', token.DEC)
			if tok == token.DEC {
				insertSemi = true
			}
		case '*':
			tok = s.switch2(token.MUL, token.MUL_ASSIGN)
		case '/':
			if s.ch == '/' || s.ch == '*' {
				// 注释
				if s.insertSemi && s.findLineEnd() {
					// 将位置重置为注释的开头
					s.ch = '/'
					s.offset = s.file.Offset(pos)
					s.rdOffset = s.offset + 1
					s.insertSemi = false // 换行符已消费
					return pos, token.SEMICOLON, "\n"
				}
				comment := s.scanComment()
				if s.mode&ScanComments == 0 {
					// 跳过注释
					s.insertSemi = false // 换行符已消费
					goto scanAgain
				}
				tok = token.COMMENT
				lit = comment
			} else {
				tok = s.switch2(token.QUO, token.QUO_ASSIGN)
			}
		case '%':
			tok = s.switch2(token.REM, token.REM_ASSIGN)
		case '^':
			tok = s.switch2(token.XOR, token.XOR_ASSIGN)
		case '<':
			if s.ch == '-' {
				s.next()
				tok = token.ARROW
			} else {
				tok = s.switch4(token.LSS, token.LEQ, '<', token.SHL, token.SHL_ASSIGN)
			}
		case '>':
			tok = s.switch4(token.GTR, token.GEQ, '>', token.SHR, token.SHR_ASSIGN)
		case '=':
			tok = s.switch2(token.ASSIGN, token.EQL)
		case '!':
			tok = s.switch2(token.NOT, token.NEQ)
		case '&':
			if s.ch == '^' {
				s.next()
				tok = s.switch2(token.AND_NOT, token.AND_NOT_ASSIGN)
			} else {
				tok = s.switch3(token.AND, token.AND_ASSIGN, '&', token.LAND)
			}
		case '|':
			tok = s.switch3(token.OR, token.OR_ASSIGN, '|', token.LOR)
		case '~':
			tok = token.TILDE
		default:
			// 下次报告意外的BOM-不要重复
			if ch != bom {
				s.errorf(s.file.Offset(pos), "illegal character %#U", ch)
			}
			insertSemi = s.insertSemi // 保留插入的半信息
			tok = token.ILLEGAL
			lit = string(ch)
		}
	}
	if s.mode&dontInsertSemis == 0 {
		s.insertSemi = insertSemi
	}

	return
}
